package com.ruoyi.system.service.report.Impl;

import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.TreeSelect;
import com.ruoyi.common.core.domain.entity.TempleLib;
import com.ruoyi.common.exception.GlobalException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.rtf.RtfToZh;
import com.ruoyi.exam.mapper.TabStatusMapper;
import com.ruoyi.system.domain.*;
import com.ruoyi.system.domain.report.vo.*;
import com.ruoyi.system.domain.vo.GetPdtdVo;
import com.ruoyi.system.domain.vo.ReTabPtdetailTailPatientVo;
import com.ruoyi.system.mapper.TabPtdetailMapper;
import com.ruoyi.system.mapper.report.TeacherMapper;
import com.ruoyi.system.service.report.ITeacherService;
import org.apache.ibatis.jdbc.Null;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;


@Service
public class ITeacherServiceImpl  implements ITeacherService {

    @Autowired
    private TeacherMapper teacherMapper;

    @Autowired
    private TabStatusMapper tabStatusMapper;

    @Autowired
    private TabPtdetailMapper tabPtdetailMapper;


    /**
     * 条件分页查询
     *
     * @param
     */
    @Override
    public TabPtdetailTailPatientTotalVO getList(TabPtdetailTailPatientVO tabPtdetailTailPatientVO) {
        List<ReTabPtdetailTailPatientVo> list = teacherMapper.getPydetailList(tabPtdetailTailPatientVO);
        TabPtdetailTailPatientTotalVO tabPtdetailTailPatientTotalVO = new TabPtdetailTailPatientTotalVO();
        // 计算年龄，并处理
        List<ReTabPtdetailTailPatientVo> collect = list.stream().peek(vo -> {
            vo.setAge(vo.getPtBirthday() == null ? null : DateUtils.getAge(vo.getPtBirthday()));
            //将yyyy-MM-dd HH:mm:ss.S转化为yyyy-MM-dd HH:mm
            vo.setPtdtReportDate(vo.getPtdtReportDate() == null ? null : DateUtils.dateTimeToString(vo.getPtdtReportDate(),"yyyy-MM-dd HH:mm"));
        }).collect(Collectors.toList());
        tabPtdetailTailPatientTotalVO.setTotal(teacherMapper.totalCount(tabPtdetailTailPatientVO));
        tabPtdetailTailPatientTotalVO.setTabPtdetailTailPatientVO(collect);
        return tabPtdetailTailPatientTotalVO;
    }

    /**
     * 下拉检查项目
     * @return
     */
    @Override
    public List<String> getDropDownCheckName() {
        return teacherMapper.getDropDownCheckName();
    }

    /**
     * 下拉检查状态
     *
     * @return
     */
    @Override
    public List<StatusVo> getDropDownState() {
        return teacherMapper.getDropDownState();
    }

    /**
     * 随访信息查询
     *
     * @param ptdeId
     * @return
     */
    @Override
    public SurveyVo getSurvey(String ptdeId) {
        return teacherMapper.getSurvey(ptdeId);
    }

    /**
     * 查询病史
     * @param
     * @return
     */
    @Override
    public PtDetailBgReadyVo getBgReadyTxt(String ptdeId,String userName,String reportId) {
            return teacherMapper.getBgReadyTxt(ptdeId);
    }

    /**
     * 检查意见
     *
     * @param patientId
     * @return
     */
    @Override
    public PtCheckOpinionVo ptdtCheckyjTxt(String patientId) {
        return teacherMapper.ptdtCheckyjTxt(patientId);
    }

    /**
     * 检查所见
     *
     * @param patientId
     * @return
     */
    @Override
    public PtDetailCheckSeeTxtVo ptdtCheckSjTxt(String patientId) {
        return teacherMapper.ptdtCheckSjTxt(patientId);
    }

    /**
     * 学生患者查询
     *
     * @param
     * @return
     */
    @Override
    public PtPatientVo getPatient(String ptdeId) {
        PtPatientVo patient = teacherMapper.getPatient(ptdeId);
        return patient;
    }

    /**
     * 修改患者信息
     * @param ptPatientVo
     * @return
     */
    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,timeout=36000,rollbackFor=Exception.class)
    @Override
    public void updatePatient(PtPatientVo ptPatientVo) {
        System.out.println(ptPatientVo);
        teacherMapper.updatePtdetail(ptPatientVo);
        teacherMapper.updatePatient(ptPatientVo);
    }

    /**
     * 获取历史记录
     * @param
     * @return
     */
    @Override
    public List<HistoryVo> getHistory(String patientId, String ptdeId) {
        List<HistoryVo> list = teacherMapper.getHistory(patientId,ptdeId);
        return list;
    }

    /**
     * 获取病人 随访,病史,检查所见,检查意见
     * @param
     * @return
     */
    @Override
    public HistoryVo getPatientReportInfo(String ptdeId) {
        return teacherMapper.getPatientReportInfo(ptdeId);
    }

    /**
     * 序列
     * @param
     * @return
     */
    @Override
    public List<StudiesSeriesVo>  getStudiesSeries(String checkCode) {
        return teacherMapper.getStudiesSeries(checkCode);
    }

    /**
     * 查询模板树
     * @return
     */
    @Override
    public HashMap<String, List<TreeSelect>> getTemplate(Long userId) {
        List<TempleLib> list = teacherMapper.getTempleTree(userId);
        List<TempleLib> depts = templeLibTree(list);
        List<TreeSelect> collect = depts.stream().map(TreeSelect::new).collect(Collectors.toList());
       HashMap<String, List<TreeSelect>> stringArrayListHashMap = new HashMap<>();
       stringArrayListHashMap.put("public",collect);
       return stringArrayListHashMap;
    }

    /**
     * 检查意见,检查所见模板
     * @param id
     * @param parentId
     * @return
     */
    @Override
    public TemplateInfo templateInfo(String id, String parentId) {
        TemplateInfo templateInfo = teacherMapper.getTemplateInfo(id, parentId);
        if (templateInfo != null){
            try {
                templateInfo.setLibCheckSj(extractChinese(templateInfo.getLibCheckSj()));
                templateInfo.setLibCheckYj(extractChinese(templateInfo.getLibCheckYj()));
            } catch (RuntimeException e) {
                e.printStackTrace();
            }
            return templateInfo;
        }
        return null;
    }

    public static String extractChinese(String rtfContent) {
    if (rtfContent == null || rtfContent.isEmpty()) {
        return "";
    }
    // 使用正则匹配所有中文字符
    return rtfContent.replaceAll("[^\\u4e00-\\u9fa5]", "");
}


    /**
     * 获取当前用户管理的所有班级
     * @param userName
     * @return
     */
    @Override
    public List<ClassLIstVo> getClassList(String userName) {
        //校验当前用户是否为教师
//        if(){
//
//        }
        return teacherMapper.getClassList(userName);
    }

    /**
     * 获取当前用户拥有班级的所有学生
     * @param
     * @param classZ
     * @return
     */
    @Override
    public List<ClassStudentListResVo> getClassStudentList(String classZ) {
        return teacherMapper.getClassStudentList(classZ);
    }

    /**
     * 发布患者报告
     * @param
     * @param
     */
    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,timeout=36000,rollbackFor=Exception.class)
    @Override
    public void addRelease(List<ClassStudentListVo> list,String teacherUserName) {
        teacherMapper.addReport(list,teacherUserName);
    }

    /**
     * 教师查询患者报告
     * @param studentReportReqVo
     * @param
     * @return
     */
    @Override
    public List<StudentReportListPageResVo> getStudentReportListPage(StudentReportReqVo studentReportReqVo, String userName) {

        return teacherMapper.getStudentReportListPage(userName,studentReportReqVo);
    }

    /**
     * 评价,评分
     * @param commentScoreReqVo
     */
    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,timeout=36000,rollbackFor=Exception.class)
    @Override
    public void addCommentScore(CommentScoreReqVo commentScoreReqVo,String status) {
        teacherMapper.addCommentScore(commentScoreReqVo);
        teacherMapper.updateReport(commentScoreReqVo,status);
        try {
        } catch (Exception e) {
            throw new GlobalException("新增评价失败,请联系管理员");
        }
    }

    /**
     * 修改评价
     * @param commentScoreReqVo
     */
    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,timeout=36000,rollbackFor=Exception.class)
    @Override
    public void updateCommentScore(CommentScoreReqVo commentScoreReqVo) {
        teacherMapper.updateCommentScore(commentScoreReqVo);
        teacherMapper.updateReport(commentScoreReqVo,"1");
        try {
        } catch (Exception e) {
            throw new GlobalException("更新评价失败,请联系管理员");
        }

    }

    @Override
    public  List<String> getCompleteStatus() {
        List<String> completeStatus = teacherMapper.getCompleteStatus();
        return completeStatus;
    }

    @Override
    public CommentReportResVo getReportComment(String reportId) {
        return teacherMapper.getReportComment(reportId);
    }


    @Override
    public List<DICOMSeriesImgVo> getStudyInsta(String studyInsta) {
        return teacherMapper.getStudyInsta(studyInsta);
    }

  @Override
  public List<String> getDropDownCheckMachine() {
    return teacherMapper.getDropDownCheckMachine();
  }

  @Override
  public List<String> getDropDownXxj() {
    return teacherMapper.getDropDownXxj();
  }

  @Override
  public List<HistoryVo2> getHistoryByCheckCode(String ptdtCheckCode) {

      List<HistoryVo2> list = teacherMapper.getHistoryByCheckCode(ptdtCheckCode);
      return list;

  }

  @Override
  public List<HistoryVo2> getHistoryByPtName(String ptName) {
    List<HistoryVo2> list = teacherMapper.getHistoryByPtName(ptName);
    return list;
  }

  @Override
  public PtPatienVo2 getPatientPro(String ptdeId) {
      PtPatienVo2 patient = teacherMapper.getPatientPro(ptdeId);
    return patient;
  }

  @Override
  public void updateMyTemplate(TemplateUpdata template) {
       teacherMapper.updateMyTemplate(template);
       return;
  }

  @Override
  public List<String> getDropDownModelName() {
     return teacherMapper.getDropDownModelName();
  }

  @Override
  public List<String> getDropDownPtdtModelName() {
    return teacherMapper.getDropDownPtdtModelName();
  }

  @Override
  public void addMyTemplate(TemplateUpdata template) {
    teacherMapper.addMyTemplate(template);
    return;
  }

  @Override
  public void delMyTemplate(TemplateUpdata template) {
    teacherMapper.delMyTemplate(template);
  }

//  删除一个节点下的所有子节点模板
  @Override
  public void delMyChildrenTemplate(List<TempleLib> templeLiblist) {
      for(TempleLib templeLib : templeLiblist ){
        List<TempleLib> childrendList = templeLib.getChildren();
        if(childrendList.isEmpty()){
          teacherMapper.delMyChildrenTemplate(templeLib);
        }
        else {
          delMyChildrenTemplate(templeLib.getChildren());
          teacherMapper.delMyChildrenTemplate(templeLib);
        }
      }
  }

  @Override
  public List<String> GetEquipments() {
    return teacherMapper.GetEquipments();
  }


  private List<TempleLib> templeLibTree(List<TempleLib> depts)
    {
        List<TempleLib> returnList = new ArrayList<TempleLib>();
        List<Long> tempList = new ArrayList<Long>();
        for (TempleLib dept : depts)
        {
            tempList.add(dept.getId());
        }
        for (Iterator<TempleLib> iterator = depts.iterator(); iterator.hasNext();)
        {
            TempleLib dept = (TempleLib) iterator.next();
            // 如果是顶级节点, 遍历该父节点的所有子节点
            if (!tempList.contains(dept.getLibParentId()))
            {
                recursionFn(depts, dept);
                returnList.add(dept);
            }
        }
        if (returnList.isEmpty())
        {
            returnList = depts;
        }
        return returnList;
    }

    private void recursionFn(List<TempleLib> list, TempleLib t)
    {
        // 得到子节点列表
        List<TempleLib> childList = getChildList(list, t);
        t.setChildren(childList);
        for (TempleLib tChild : childList)
        {
            if (hasChild(list, tChild))
            {
                recursionFn(list, tChild);
            }
        }
    }


    private List<TempleLib> getChildList(List<TempleLib> list, TempleLib t)
    {
        List<TempleLib> tlist = new ArrayList<TempleLib>();
        Iterator<TempleLib> it = list.iterator();
        while (it.hasNext())
        {
            TempleLib n = (TempleLib) it.next();
            if (StringUtils.isNotNull(n.getLibParentId()) && n.getLibParentId().longValue() == t.getId().longValue())
            {
                tlist.add(n);
            }
        }
        return tlist;
    }

    private boolean hasChild(List<TempleLib> list, TempleLib t)
    {
        return getChildList(list, t).size() > 0;
    }

    @Override
    public List<String> GetBranch(){
      return teacherMapper.GetBranch();
    }

   @Override
   public List<TabPtdetailTailPatientVO> GetBgDoctor(String ptName){
      return teacherMapper.GetBgDoctor(ptName);
   }

   @Override
   public List<String> getDoctorDropDown(){
       return teacherMapper.getDoctorDropDown();
   }

   @Override
   public void changePtInfo(TabPtdetailTailPatientVO tabPtdetailTailPatientVO){
      teacherMapper.changePtInfo(tabPtdetailTailPatientVO);
   }

    /**
     * 报告医生
     * @param bgDto
     * @return
     */
    // 报告提取
    @Override
    public AjaxResult ExtractReport(BgDto bgDto) {
        // 根据id获取报告信息
        TabPtdetail tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

        // 如果报告医生为空
        if ("".equals(tabPtdetail.getPtdtBgdoctor()) || tabPtdetail.getPtdtBgdoctor() == null) {
            // 修改状态为报告中RS_REPORTING
            tabPtdetail.setPtdtStatus("RS_REPORTING");
            // 修改报告医生为本人
            tabPtdetail.setPtdtBgdoctor(bgDto.getName());

            // 修改时间
            Date date = new Date();
            tabPtdetail.setPtdtReportdate(date);
            // 更新数据库中信息
            tabPtdetailMapper.updateTabPtdetail(tabPtdetail);

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtBgdoctor(), tabPtdetail.getPtdtReportdate());

            return AjaxResult.success("报告提取成功!", getPdtdVo);

            // 如果报告中
        } else if ("RS_REPORTING".equals(tabPtdetail.getPtdtStatus())) {
            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtBgdoctor(), tabPtdetail.getPtdtReportdate());

            return AjaxResult.error("报告已提取！", getPdtdVo);
        }

        return AjaxResult.error("报告状态异常");
    }

    // 撤销报告提取
    @Override
    public AjaxResult returnPtdStatus(BgDto bgDto) {
        // 根据id获取报告信息
        TabPtdetail tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

        // 如果报告处于报告中RS_REPORTING，并且医生为本人
        if ("RS_REPORTING".equals(tabPtdetail.getPtdtStatus()) && bgDto.getName().equals(tabPtdetail.getPtdtBgdoctor())) {
            // 更新状态为已采集RS_NOREPORT
            tabPtdetail.setPtdtStatus("RS_NOREPORT");
            // 更新报告医生为空
            tabPtdetail.setPtdtBgdoctor("");
            // 更新数据库
            tabPtdetailMapper.updateTabPtdetail(tabPtdetail);

            // 更新操作时间
            tabPtdetailMapper.updatePtdtReportdate(tabPtdetail.getPtdeid());

            // 更新数据
            tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(bgDto.getName(), tabPtdetail.getPtdtReportdate());

            return AjaxResult.success("撤销提取成功！", getPdtdVo);

            // 如果报告中但不是本人操作
        } else if ("RS_REPORTING".equals(tabPtdetail.getPtdtStatus()) && !(bgDto.getName().equals(tabPtdetail.getPtdtBgdoctor()))) {

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtBgdoctor(), tabPtdetail.getPtdtReportdate());
            return AjaxResult.error("非本人操作!", getPdtdVo);
        }

        return AjaxResult.error("报告状态异常");
    }

    // 返回所有报告医生
    @Override
    public List<DoctorDto> AllBgDoctor() {
        return tabPtdetailMapper.selectBgDoctor();
    }

    // 提交审核
    @Override
    public AjaxResult submitCommited(BgDto bgDto) {
        // 根据id获取报告信息
        TabPtdetail tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

        // 如果报告处于报告中RS_REPORTING，并且医生为本人
        if ("RS_REPORTING".equals(tabPtdetail.getPtdtStatus()) && bgDto.getName().equals(tabPtdetail.getPtdtBgdoctor())) {
            // 更新状态为待审核RS_COMMITED
            tabPtdetail.setPtdtStatus("RS_COMMITED");
            // 更新操作时间
            Date date = new Date();
            tabPtdetail.setPtdtReportdate(date);

            // 更新数据库
            tabPtdetailMapper.updateTabPtdetail(tabPtdetail);

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtBgdoctor(), tabPtdetail.getPtdtReportdate());

            return AjaxResult.success("提交审核成功！", getPdtdVo);

            // 如果报告中但不是本人操作
        } else if ("RS_REPORTING".equals(tabPtdetail.getPtdtStatus()) && !(bgDto.getName().equals(tabPtdetail.getPtdtBgdoctor()))) {

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtBgdoctor(), tabPtdetail.getPtdtReportdate());
            return AjaxResult.error("非本人操作!", getPdtdVo);
        }

        return AjaxResult.success("报告状态修改完成，请勿频繁点击修改");
    }

    // 撤销提交审核
    @Override
    public AjaxResult backCommited(BgDto bgDto) {
        // 根据id获取报告信息
        TabPtdetail tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

        // 如果报告处于待审核RS_COMMITED，并且医生为本人
        if ("RS_COMMITED".equals(tabPtdetail.getPtdtStatus()) && bgDto.getName().equals(tabPtdetail.getPtdtBgdoctor())) {
            // 更新状态为报告中RS_REPORTING
            tabPtdetail.setPtdtStatus("RS_REPORTING");
            // 更新操作时间
            Date date = new Date();
            tabPtdetail.setPtdtReportdate(date);

            // 更新数据库
            tabPtdetailMapper.updateTabPtdetail(tabPtdetail);

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtBgdoctor(), tabPtdetail.getPtdtReportdate());

            return AjaxResult.success("撤销提交审核成功！", getPdtdVo);

            // 如果待审核但不是本人
        } else if ("RS_COMMITED".equals(tabPtdetail.getPtdtStatus()) && !(bgDto.getName().equals(tabPtdetail.getPtdtBgdoctor()))) {

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtBgdoctor(), tabPtdetail.getPtdtReportdate());
            return AjaxResult.error("非本人操作!", getPdtdVo);
        }
        return AjaxResult.error("报告状态异常");
    }


    /**
     * 审核医生
     * @param bgDto
     * @return
     */
    // 审核提取
    @Override
    public AjaxResult ExtractSHReport(BgDto bgDto) {
        // 根据id获取报告信息
        TabPtdetail tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

        // 如果审核医生为空并且报告状态为待审核RS_COMMITED
        if (("".equals(tabPtdetail.getPtdtShdoctor()) || tabPtdetail.getPtdtShdoctor() == null) && "RS_COMMITED".equals(tabPtdetail.getPtdtStatus())) {
            // 修改状态为审核中RS_AUDITING
            tabPtdetail.setPtdtStatus("RS_AUDITING");
            // 修改审核医生为本人
            tabPtdetail.setPtdtShdoctor(bgDto.getName());

            // 修改时间
            Date date = new Date();
            tabPtdetail.setPtdtShdate(date);
            // 更新数据库中信息
            tabPtdetailMapper.updateTabPtdetail(tabPtdetail);

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor(), tabPtdetail.getPtdtShdate());

            return AjaxResult.success("审核提取成功!", getPdtdVo);

            // 如果审核中RS_AUDITING
        } else if ("RS_AUDITING".equals(tabPtdetail.getPtdtStatus())) {
            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor(), tabPtdetail.getPtdtShdate());

            return AjaxResult.error("审核已提取！", getPdtdVo);
        }

        return AjaxResult.error("报告状态异常");
    }

    // 撤销审核提取
    @Override
    public AjaxResult returnPtdStatus2(BgDto bgDto) {
        // 根据id获取报告信息
        TabPtdetail tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

        // 如果审核医生为本人并且报告状态为审核中RS_AUDITING
        if (bgDto.getName().equals(tabPtdetail.getPtdtShdoctor()) && "RS_AUDITING".equals(tabPtdetail.getPtdtStatus())) {
            // 修改状态为待审核 RS_COMMITED
            tabPtdetail.setPtdtStatus("RS_COMMITED");
            // 修改审核医生为空
            tabPtdetail.setPtdtShdoctor("");


            // 更新数据库中信息
            tabPtdetailMapper.updateTabPtdetail(tabPtdetail);

            // 修改时间
            tabPtdetailMapper.updatePtdtShDate(tabPtdetail.getPtdeid());

            // 更新数据
            tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(bgDto.getName(), tabPtdetail.getPtdtShdate());

            return AjaxResult.success("撤销审核提取成功!", getPdtdVo);

            // 如果审核中RS_AUDITING 但不是本人操作
        } else if ("RS_AUDITING".equals(tabPtdetail.getPtdtStatus()) && !(bgDto.getName().equals(tabPtdetail.getPtdtShdoctor()))) {
            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor(), tabPtdetail.getPtdtShdate());

            return AjaxResult.error("非本人操作！", getPdtdVo);
        }

        return AjaxResult.error("报告状态异常");
    }

    // 审核通过
    @Override
    public AjaxResult ReportApproved(BgDto bgDto) {
        // 根据id获取报告信息
        TabPtdetail tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

        // 如果审核医生为本人并且报告状态为审核中RS_AUDITING
        if (bgDto.getName().equals(tabPtdetail.getPtdtShdoctor()) && "RS_AUDITING".equals(tabPtdetail.getPtdtStatus())) {
            // 修改状态为已审核 RS_AUDITED
            tabPtdetail.setPtdtStatus("RS_AUDITED");

            // 修改时间
            Date date = new Date();
            tabPtdetail.setPtdtShdate(date);
            // 更新数据库中信息
            tabPtdetailMapper.updateTabPtdetail(tabPtdetail);

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor(), tabPtdetail.getPtdtShdate());

            return AjaxResult.success("审核通过!", getPdtdVo);

            // 如果审核中RS_AUDITING 并且不是本人操作
        } else if ("RS_AUDITING".equals(tabPtdetail.getPtdtStatus()) && !(bgDto.getName().equals(tabPtdetail.getPtdtShdoctor()))) {
            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor(), tabPtdetail.getPtdtShdate());

            return AjaxResult.error("非本人操作！", getPdtdVo);
        }

        return AjaxResult.error("报告状态异常");
    }

    // 获取所有审核医生
    @Override
    public List<DoctorDto> AllShDoctor() {
        return tabPtdetailMapper.selectShDoctor();
    }

    // 转审
    @Override
    public AjaxResult changeShDoctor(BgDto bgDto) {
        // 根据id获取报告信息
        TabPtdetail tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

        // 如果审核医生为本人并且报告状态为审核中RS_AUDITING
        if (bgDto.getName().equals(tabPtdetail.getPtdtShdoctor()) && "RS_AUDITING".equals(tabPtdetail.getPtdtStatus())) {
            // 修改审核医生为新的
            tabPtdetail.setPtdtShdoctor(bgDto.getZsshname());

            // 修改时间
            Date date = new Date();
            tabPtdetail.setPtdtShdate(date);
            // 更新数据库中信息
            tabPtdetailMapper.updateTabPtdetail(tabPtdetail);

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor(), tabPtdetail.getPtdtShdate());

            return AjaxResult.success("转审成功!", getPdtdVo);

            // 如果审核中RS_AUDITING 但不是本人操作
        } else if ("RS_AUDITING".equals(tabPtdetail.getPtdtStatus()) && !(bgDto.getName().equals(tabPtdetail.getPtdtShdoctor()))) {
            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor(), tabPtdetail.getPtdtShdate());

            return AjaxResult.error("非本人操作！", getPdtdVo);
        }

        return AjaxResult.error("报告状态异常");
    }

    // 提交复审
    @Override
    public AjaxResult submitCommited2(BgDto bgDto) {
        // 根据id获取报告信息
        TabPtdetail tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

        // 如果报告处于审核中 RS_AUDITING，并且医生为本人
        if ("RS_AUDITING".equals(tabPtdetail.getPtdtStatus()) && bgDto.getName().equals(tabPtdetail.getPtdtShdoctor())) {
            // 更新状态为待复审 RS_COMMITED2
            tabPtdetail.setPtdtStatus("RS_COMMITED2");
            // 更新操作时间
            Date date = new Date();
            tabPtdetail.setPtdtShdate(date);

            // 更新数据库
            tabPtdetailMapper.updateTabPtdetail(tabPtdetail);

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor(), tabPtdetail.getPtdtShdate());

            return AjaxResult.success("提交复审成功！", getPdtdVo);

            // 如果审核中RS_AUDITING 但不是本人操作
        } else if ("RS_AUDITING".equals(tabPtdetail.getPtdtStatus()) && !(bgDto.getName().equals(tabPtdetail.getPtdtShdoctor()))) {

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor(), tabPtdetail.getPtdtShdate());
            return AjaxResult.error("非本人操作!", getPdtdVo);
        }

        return AjaxResult.error("报告状态异常");
    }

    // 撤销提交复审
    @Override
    public AjaxResult backCommited2(BgDto bgDto) {
        // 根据id获取报告信息
        TabPtdetail tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

        // 如果审核医生为本人并且报告状态为待复审 RS_COMMITED2
        if (bgDto.getName().equals(tabPtdetail.getPtdtShdoctor()) && "RS_COMMITED2".equals(tabPtdetail.getPtdtStatus())) {
            // 修改状态为审核中 RS_AUDITING
            tabPtdetail.setPtdtStatus("RS_AUDITING");

            // 修改时间
            tabPtdetail.setPtdtShdate(null);
            // 更新数据库中信息
            tabPtdetailMapper.updateTabPtdetail(tabPtdetail);

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor(), tabPtdetail.getPtdtShdate());

            return AjaxResult.success("撤销提交复审成功!", getPdtdVo);

            // 如果待复审 RS_COMMITED2 但不是本人操作
        } else if ("RS_COMMITED2".equals(tabPtdetail.getPtdtStatus()) && !(bgDto.getName().equals(tabPtdetail.getPtdtShdoctor()))) {
            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor(), tabPtdetail.getPtdtShdate());

            return AjaxResult.error("非本人操作！", getPdtdVo);
        }

        return AjaxResult.error("报告状态异常");
    }


    /**
     * 复审医生
     * @param bgDto
     * @return
     */
    // 复审提取
    @Override
    public AjaxResult changePtdStatus3(BgDto bgDto) {
        // 根据id获取报告信息
        TabPtdetail tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

        // 如果复审医生为空并且报告状态为待复审 RS_COMMITED2
        if (("".equals(tabPtdetail.getPtdtShdoctor2()) || tabPtdetail.getPtdtShdoctor2() == null) && "RS_COMMITED2".equals(tabPtdetail.getPtdtStatus())) {
            // 修改状态为复审中 RS_AUDITING2
            tabPtdetail.setPtdtStatus("RS_AUDITING2");
            // 修改审核医生为本人
            tabPtdetail.setPtdtShdoctor2(bgDto.getName());

            // 修改时间
            Date date = new Date();
            tabPtdetail.setPtdtShdate2(date);
            // 更新数据库中信息
            tabPtdetailMapper.updateTabPtdetail(tabPtdetail);

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor2(), tabPtdetail.getPtdtShdate2());

            return AjaxResult.success("复审提取成功!", getPdtdVo);

            // 如果复审中 RS_AUDITING2
        } else if ("RS_AUDITING2".equals(tabPtdetail.getPtdtStatus())) {
            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor2(), tabPtdetail.getPtdtShdate2());

            return AjaxResult.error("复审已提取！", getPdtdVo);
        }

        return AjaxResult.error("报告状态异常");
    }


    // 撤销复审提取
    @Override
    public AjaxResult returnPtdStatus3(BgDto bgDto) {
        // 根据id获取报告信息
        TabPtdetail tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

        // 如果复审医生为本人并且报告状态为复审中RS_AUDITING2
        if (bgDto.getName().equals(tabPtdetail.getPtdtShdoctor2()) && "RS_AUDITING2".equals(tabPtdetail.getPtdtStatus())) {
            // 修改状态为待复审 RS_COMMITED2
            tabPtdetail.setPtdtStatus("RS_COMMITED2");
            // 修改复审医生为空
            tabPtdetail.setPtdtShdoctor2("");

            // 更新数据库中信息
            tabPtdetailMapper.updateTabPtdetail(tabPtdetail);

            // 修改时间
            tabPtdetailMapper.updatePtdtShdate2(tabPtdetail.getPtdeid());

            // 更新数据
            tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(bgDto.getName(), tabPtdetail.getPtdtShdate2());

            return AjaxResult.success("撤销复审提取成功!", getPdtdVo);

            // 如果审核中RS_AUDITING 但非本人操作
        } else if ("RS_AUDITING".equals(tabPtdetail.getPtdtStatus()) && !(bgDto.getName().equals(tabPtdetail.getPtdtShdoctor2()))) {
            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor2(), tabPtdetail.getPtdtShdate2());

            return AjaxResult.error("非本人操作!", getPdtdVo);
        }

        return AjaxResult.error("报告状态异常");
    }

    // 复审通过
    @Override
    public AjaxResult reportApproved2(BgDto bgDto) {
        // 根据id获取报告信息
        TabPtdetail tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

        // 如果复审医生为本人并且报告状态为复审中RS_AUDITING2
        if (bgDto.getName().equals(tabPtdetail.getPtdtShdoctor2()) && "RS_AUDITING2".equals(tabPtdetail.getPtdtStatus())) {
            // 修改状态为已复审 RS_AUDITED2
            tabPtdetail.setPtdtStatus("RS_AUDITED2");

            // 修改时间
            Date date = new Date();
            tabPtdetail.setPtdtShdate2(date);
            // 更新数据库中信息
            tabPtdetailMapper.updateTabPtdetail(tabPtdetail);

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor2(), tabPtdetail.getPtdtShdate2());

            return AjaxResult.success("复审通过!", getPdtdVo);

            // 如果复审中RS_AUDITING 并且不是本人操作
        } else if ("RS_AUDITING2".equals(tabPtdetail.getPtdtStatus()) && !(bgDto.getName().equals(tabPtdetail.getPtdtShdoctor2()))) {
            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor2(), tabPtdetail.getPtdtShdate2());

            return AjaxResult.error("非本人操作！", getPdtdVo);
        }

        return AjaxResult.error("报告状态异常");
    }

    // 获取所有复审医生
    @Override
    public List<DoctorDto> AllFsDoctor() {
        return tabPtdetailMapper.selectShDoctor2();
    }

    // 转复审
    @Override
    public AjaxResult changeShDoctor2(BgDto bgDto) {
        // 根据id获取报告信息
        TabPtdetail tabPtdetail = tabPtdetailMapper.selectTabPtdetailByPtdeid(bgDto.getId());

        // 如果复审医生为本人并且报告状态为复审中 RS_AUDITING2
        if (bgDto.getName().equals(tabPtdetail.getPtdtShdoctor2()) && "RS_AUDITING2".equals(tabPtdetail.getPtdtStatus())) {
            // 修改审核医生为新的
            tabPtdetail.setPtdtShdoctor2(bgDto.getZsshname2());

            // 修改时间
            Date date = new Date();
            tabPtdetail.setPtdtShdate2(date);
            // 更新数据库中信息
            tabPtdetailMapper.updateTabPtdetail(tabPtdetail);

            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor2(), tabPtdetail.getPtdtShdate2());

            return AjaxResult.success("转复审成功!", getPdtdVo);

            // 如果复审中RS_AUDITING2 但不是本人操作
        } else if ("RS_AUDITING2".equals(tabPtdetail.getPtdtStatus()) && !(bgDto.getName().equals(tabPtdetail.getPtdtShdoctor2()))) {
            // 封装返回信息
            GetPdtdVo getPdtdVo = new GetPdtdVo(tabPtdetail.getPtdtShdoctor2(), tabPtdetail.getPtdtShdate2());

            return AjaxResult.error("非本人操作！", getPdtdVo);
        }

        return AjaxResult.error("报告状态异常");
    }

    // 获取当前报告状态以及对应医生和时间
    @Override
    public TimeDoctorDto timeAndDoctor(String id) {
        return tabPtdetailMapper.selectTimeDoctorDto(Long.valueOf(id));
    }

    // 获取序列信息
    @Override
    public List<SequenceDto> getSequenceByname(List<String> nameList) {
        // 根据姓名获取对应的 patientid 列表
        List<String> patientList1 = new ArrayList<>();
        for (String name : nameList) {
            List<String> patientList2 = tabPtdetailMapper.getPatient(name);
            patientList1 = Stream.of(patientList1, patientList2).flatMap(Collection::stream).collect(Collectors.toList());
        }


        // 根据 patientid 获取对应的序列信息
        List<SequenceDto> sequenceDtoList1 = new ArrayList<>();
        for (String patientid : patientList1) {
            List<SequenceDto> sequenceDtoList2 = tabPtdetailMapper.getSequenceBypatientid(patientid);
            sequenceDtoList1 = Stream.of(sequenceDtoList1, sequenceDtoList2).flatMap(Collection::stream).collect(Collectors.toList());
        }

        // 修饰数据
        for (SequenceDto sequenceDto : sequenceDtoList1) {
            sequenceDto.setPtdtName(tabPtdetailMapper.getSequenceName(sequenceDto.getPtdtPatientid()));
            sequenceDto.setPtdtCheckDate2(sequenceDto.getPtdtCheckDate().substring(0, 10));
            sequenceDto.setPtdtCheckDate3(sequenceDto.getPtdtCheckDate().substring(11));
        }

        return sequenceDtoList1;
    }

    @Override
    public SequenceDto getSequenceByptdeid(String ptdeid) {
        SequenceDto sequenceDto = tabPtdetailMapper.getSequenceByptdeid(ptdeid);
        sequenceDto.setPtdtName(tabPtdetailMapper.getSequenceName(sequenceDto.getPtdtPatientid()));
        sequenceDto.setPtdtCheckDate2(sequenceDto.getPtdtCheckDate().substring(0, 10));
        sequenceDto.setPtdtCheckDate3(sequenceDto.getPtdtCheckDate().substring(11));
        return sequenceDto;
    }

}
